package com.wjb.xietong.ota.task;

import android.content.Context;
import android.graphics.Bitmap;
import android.graphics.Canvas;
import android.graphics.Matrix;
import android.util.AttributeSet;
import android.view.MotionEvent;
import android.view.View;

//import com.zoeice.e5.R;
//
//import android.content.Context;
//import android.graphics.Bitmap;
//import android.graphics.BitmapFactory;
//import android.graphics.Canvas;
//import android.graphics.Movie;
//import android.graphics.Point;
//import android.graphics.PointF;
//import android.util.AttributeSet;
//import android.util.DisplayMetrics;
//import android.util.FloatMath;
//import android.util.Log;
//import android.view.MotionEvent;
//import android.view.View;
//
//public class PhotoDetailView extends View {
//	private Context mContext;
//	private int mScreenWidth;
//	private int mScreenHeight;
//	private float mCurrentRate = 1;//当前放大的倍数
//	private float mOldRate = 1;//上一次放大的倍数
//	private boolean mIsFirst = true;//是否是第一次触摸屏幕
//	private float mOriginalLength;//刚触摸时两个手指的距离
//	private float mCurrentLength;//当前两个手指的距离
//	Bitmap orgBitmap = null;
//	PointF startPoint = new PointF(0,0);
//	PointF endPoint = new PointF(0,0);
//	PointF curPoint = new PointF(0,0);
//	
//	
//    static final int NONE = 0; 
//    static final int DRAG = 1; 
//    static final int ZOOM = 2; 
//    int mode = NONE; 
//    
//	public PhotoDetailView(Context context, Bitmap bitmap) {
//		super(context);
//		this.mContext = context;
//		orgBitmap = bitmap;
//		init(context);
//	}
//
//	public PhotoDetailView(Context context, AttributeSet attrs, Bitmap bitmap) {
//		super(context, attrs);
//		this.mContext = context;
//		orgBitmap = bitmap;
//		init(context);
//	}
//
//	private void init(Context context) {
//		DisplayMetrics display = context.getResources().getDisplayMetrics();
//		mScreenWidth = display.widthPixels;
//		mScreenHeight = display.heightPixels;
//		startPoint.x = mScreenWidth /2 - orgBitmap.getWidth() / 2;
//		startPoint.y = mScreenHeight / 2 - orgBitmap.getHeight() / 2;
//	}
//	
//	@Override
//	protected void onDraw(Canvas canvas) {
//		canvas.save();
//		canvas.scale(mCurrentRate, mCurrentRate, mScreenWidth /2 ,  mScreenHeight / 2);
//
//		Log.i("e5" , "onDraw:startPointX = " + startPoint.x + ", startPointY = " + startPoint.y);
//		canvas.drawBitmap(orgBitmap, startPoint.x  + endPoint.x, startPoint.y + endPoint.y, null);
//	}
//
//	@Override
//	public boolean onTouchEvent(MotionEvent event) {
//		switch (event.getAction()) {
//        case MotionEvent.ACTION_DOWN:   	
//            	curPoint.set(event.getX(), event.getY());
//            break; 
//		case MotionEvent.ACTION_MOVE:
//			if (event.getPointerCount() == 2) {		
//				if (mIsFirst) {
//					mOriginalLength = spacing(event);
//					mIsFirst = false;
//				} else {
//					mCurrentLength = spacing(event);
//					mCurrentRate = (float) (mOldRate * (mCurrentLength / mOriginalLength));
//					invalidate();
//				}
//			} else if  (event.getPointerCount() == 1 && mode != ZOOM){				
//				mode = DRAG;  
//				Log.i("e5", "mode = " + mode );
//				endPoint.x = event.getX() - curPoint.x;
//				endPoint.y = event.getY() - curPoint.y;
//				invalidate();
//			}
//
//			break;
//		case MotionEvent.ACTION_UP:
//			if(mode == ZOOM) {
//				mOldRate = mCurrentRate;
//			} else if(mode == DRAG)  {
//				startPoint.set( startPoint.x  + endPoint.x, startPoint.y + endPoint.y);
//			}
//			
//			mIsFirst = true;
//			break;
//		}
//		return true;
//	}
//
//    private float spacing(MotionEvent event) { 
//        float x = event.getX(0) - event.getX(1); 
//        float y = event.getY(0) - event.getY(1); 
//        return FloatMath.sqrt(x * x + y * y); 
//}
//}

public class PhotoDetailView extends View {  
    
    /** 
     * 初始化状态常量 
     */
    public static final int STATUS_INIT = 1;  
       
    /** 
     * 图片放大状态常量 
     */
    public static final int STATUS_ZOOM_OUT = 2;  
       
    /** 
     * 图片缩小状态常量 
     */
    public static final int STATUS_ZOOM_IN = 3;  
       
    /** 
     * 图片拖动状态常量 
     */
    public static final int STATUS_MOVE = 4;  
       
    /** 
     * 图片最大缩放倍数
     */
    public static final int MAX_SCALE = 8;  
    /** 
     * 用于对图片进行移动和缩放变换的矩阵 
     */
    private Matrix matrix = new Matrix();  
       
    /** 
     * 待展示的Bitmap对象 
     */
    private Bitmap sourceBitmap;  
       
    /** 
     * 记录当前操作的状态，可选值为STATUS_INIT、STATUS_ZOOM_OUT、STATUS_ZOOM_IN和STATUS_MOVE 
     */
    private int currentStatus;  
       
    /** 
     * ZoomImageView控件的宽度 
     */
    private int width;  
       
    /** 
     * ZoomImageView控件的高度 
     */
    private int height;  
       
    /** 
     * 记录两指同时放在屏幕上时，中心点的横坐标值 
     */
    private float centerPointX;  
       
    /** 
     * 记录两指同时放在屏幕上时，中心点的纵坐标值 
     */
    private float centerPointY;  
       
    /** 
     * 记录当前图片的宽度，图片被缩放时，这个值会一起变动 
     */
    private float currentBitmapWidth;  
       
    /** 
     * 记录当前图片的高度，图片被缩放时，这个值会一起变动 
     */
    private float currentBitmapHeight;  
       
    /** 
     * 记录上次手指移动时的横坐标 
     */
    private float lastXMove = -1;  
       
    /** 
     * 记录上次手指移动时的纵坐标 
     */
    private float lastYMove = -1;  
       
    /** 
     * 记录手指在横坐标方向上的移动距离 
     */
    private float movedDistanceX;  
       
    /** 
     * 记录手指在纵坐标方向上的移动距离 
     */
    private float movedDistanceY;  
       
    /** 
     * 记录图片在矩阵上的横向偏移值 
     */
    private float totalTranslateX;  
       
    /** 
     * 记录图片在矩阵上的纵向偏移值 
     */
    private float totalTranslateY;  
       
    /** 
     * 记录图片在矩阵上的总缩放比例 
     */
    private float totalRatio;  
       
    /** 
     * 记录手指移动的距离所造成的缩放比例 
     */
    private float scaledRatio;  
       
    /** 
     * 记录图片初始化时的缩放比例 
     */
    private float initRatio;  
       
    /** 
     * 记录上次两指之间的距离 
     */
    private double lastFingerDis;  
       
    /** 
     * ZoomImageView构造函数，将当前操作状态设为STATUS_INIT。 
     *  
     * @param context 
     * @param attrs 
     */
    public PhotoDetailView(Context context, AttributeSet attrs) {  
        super(context, attrs);  
        currentStatus = STATUS_INIT;  
    }  
       
    /** 
     * 将待展示的图片设置进来。 
     *  
     * @param bitmap 
     *            待展示的Bitmap对象 
     */
    public void setImageBitmap(Bitmap bitmap) {  
        sourceBitmap = bitmap;  
        invalidate();  
    }  
       
    @Override
    protected void onLayout(boolean changed, int left, int top, int right, int bottom) {  
        super.onLayout(changed, left, top, right, bottom);  
        if (changed) {  
            // 分别获取到ZoomImageView的宽度和高度  
            width = getWidth();  
            height = getHeight();  
        }  
    }  
       
    @Override
    public boolean onTouchEvent(MotionEvent event) {  
        switch (event.getActionMasked()) {  
        case MotionEvent.ACTION_POINTER_DOWN:  
            if (event.getPointerCount() == 2) {  
                // 当有两个手指按在屏幕上时，计算两指之间的距离  
                lastFingerDis = distanceBetweenFingers(event);  
            }  
            break;  
        case MotionEvent.ACTION_MOVE:  
            if (event.getPointerCount() == 1) {  
                // 只有单指按在屏幕上移动时，为拖动状态  
                float xMove = event.getX();  
                float yMove = event.getY();  
                if (lastXMove == -1 && lastYMove == -1) {  
                    lastXMove = xMove;  
                    lastYMove = yMove;  
                }  
                currentStatus = STATUS_MOVE;  
                movedDistanceX = xMove - lastXMove;  
                movedDistanceY = yMove - lastYMove;  
                // 进行边界检查，不允许将图片拖出边界  
                if (totalTranslateX + movedDistanceX > 0) {  
                    movedDistanceX = 0;  
                } else if (width - (totalTranslateX + movedDistanceX) > currentBitmapWidth) {  
                    movedDistanceX = 0;  
                }  
                if (totalTranslateY + movedDistanceY > 0) {  
                    movedDistanceY = 0;  
                } else if (height - (totalTranslateY + movedDistanceY) > currentBitmapHeight) {  
                    movedDistanceY = 0;  
                }  
                // 调用onDraw()方法绘制图片  
                invalidate();  
                lastXMove = xMove;  
                lastYMove = yMove;  
            } else if (event.getPointerCount() == 2) {  
                // 有两个手指按在屏幕上移动时，为缩放状态  
                centerPointBetweenFingers(event);  
                double fingerDis = distanceBetweenFingers(event);  
                if (fingerDis > lastFingerDis) {  
                    currentStatus = STATUS_ZOOM_OUT;  
                } else {  
                    currentStatus = STATUS_ZOOM_IN;  
                }  
                // 进行缩放倍数检查，最大只允许将图片放大*倍，最小可以缩小到初始化比例  
                if ((currentStatus == STATUS_ZOOM_OUT && totalRatio < MAX_SCALE * initRatio)  
                        || (currentStatus == STATUS_ZOOM_IN && totalRatio > initRatio)) {  
                    scaledRatio = (float) (fingerDis / lastFingerDis);  
                    totalRatio = totalRatio * scaledRatio;  
                    if (totalRatio > MAX_SCALE * initRatio) {  
                        totalRatio = MAX_SCALE * initRatio;  
                    } else if (totalRatio < initRatio) {  
                        totalRatio = initRatio;  
                    }  
                    // 调用onDraw()方法绘制图片  
                    invalidate();  
                    lastFingerDis = fingerDis;  
                }  
            }  
            break;  
        case MotionEvent.ACTION_POINTER_UP:  
            if (event.getPointerCount() == 2) {  
                // 手指离开屏幕时将临时值还原  
                lastXMove = -1;  
                lastYMove = -1;  
            }  
            break;  
        case MotionEvent.ACTION_UP:  
            // 手指离开屏幕时将临时值还原  
            lastXMove = -1;  
            lastYMove = -1;  
            break;  
        default:  
            break;  
        }  
        return true;  
    }  
       
    /** 
     * 根据currentStatus的值来决定对图片进行什么样的绘制操作。 
     */
    @Override
    protected void onDraw(Canvas canvas) {  
        super.onDraw(canvas);  
        switch (currentStatus) {  
        case STATUS_ZOOM_OUT:  
        case STATUS_ZOOM_IN:  
            zoom(canvas);  
            break;  
        case STATUS_MOVE:  
            move(canvas);  
            break;  
        case STATUS_INIT:  
            initBitmap(canvas);  
        default:  
            canvas.drawBitmap(sourceBitmap, matrix, null);  
            break;  
        }  
    }  
       
    /** 
     * 对图片进行缩放处理。 
     *  
     * @param canvas 
     */
    private void zoom(Canvas canvas) {  
        matrix.reset();  
        // 将图片按总缩放比例进行缩放  
        matrix.postScale(totalRatio, totalRatio);  
        float scaledWidth = sourceBitmap.getWidth() * totalRatio;  
        float scaledHeight = sourceBitmap.getHeight() * totalRatio;  
        float translateX = 0f;  
        float translateY = 0f;  
        // 如果当前图片宽度小于屏幕宽度，则按屏幕中心的横坐标进行水平缩放。否则按两指的中心点的横坐标进行水平缩放  
        if (currentBitmapWidth < width) {  
            translateX = (width - scaledWidth) / 2f;  
        } else {  
            translateX = totalTranslateX * scaledRatio + centerPointX * (1 - scaledRatio);  
            // 进行边界检查，保证图片缩放后在水平方向上不会偏移出屏幕  
            if (translateX > 0) {  
                translateX = 0;  
            } else if (width - translateX > scaledWidth) {  
                translateX = width - scaledWidth;  
            }  
        }  
        // 如果当前图片高度小于屏幕高度，则按屏幕中心的纵坐标进行垂直缩放。否则按两指的中心点的纵坐标进行垂直缩放  
        if (currentBitmapHeight < height) {  
            translateY = (height - scaledHeight) / 2f;  
        } else {  
            translateY = totalTranslateY * scaledRatio + centerPointY * (1 - scaledRatio);  
            // 进行边界检查，保证图片缩放后在垂直方向上不会偏移出屏幕  
            if (translateY > 0) {  
                translateY = 0;  
            } else if (height - translateY > scaledHeight) {  
                translateY = height - scaledHeight;  
            }  
        }  
        // 缩放后对图片进行偏移，以保证缩放后中心点位置不变  
        matrix.postTranslate(translateX, translateY);  
        totalTranslateX = translateX;  
        totalTranslateY = translateY;  
        currentBitmapWidth = scaledWidth;  
        currentBitmapHeight = scaledHeight;  
        canvas.drawBitmap(sourceBitmap, matrix, null);  
    }  
       
    /** 
     * 对图片进行平移处理 
     *  
     * @param canvas 
     */
    private void move(Canvas canvas) {  
        matrix.reset();  
        // 根据手指移动的距离计算出总偏移值  
        float translateX = totalTranslateX + movedDistanceX;  
        float translateY = totalTranslateY + movedDistanceY;  
        // 先按照已有的缩放比例对图片进行缩放  
        matrix.postScale(totalRatio, totalRatio);  
        // 再根据移动距离进行偏移  
        matrix.postTranslate(translateX, translateY);  
        totalTranslateX = translateX;  
        totalTranslateY = translateY;  
        canvas.drawBitmap(sourceBitmap, matrix, null);  
    }  
       
    /** 
     * 对图片进行初始化操作，包括让图片居中，以及当图片大于屏幕宽高时对图片进行压缩。 
     *  
     * @param canvas 
     */
    private void initBitmap(Canvas canvas) {  
        if (sourceBitmap != null) {  
            matrix.reset();  
            int bitmapWidth = sourceBitmap.getWidth();  
            int bitmapHeight = sourceBitmap.getHeight();  
            if (bitmapWidth > width || bitmapHeight > height) {  
                if (bitmapWidth - width > bitmapHeight - height) {  
                    // 当图片宽度大于屏幕宽度时，将图片等比例压缩，使它可以完全显示出来  
                    float ratio = width / (bitmapWidth * 1.0f);  
                    matrix.postScale(ratio, ratio);  
                    float translateY = (height - (bitmapHeight * ratio)) / 2f;  
                    // 在纵坐标方向上进行偏移，以保证图片居中显示  
                    matrix.postTranslate(0, translateY);  
                    totalTranslateY = translateY;  
                    totalRatio = initRatio = ratio;  
                } else {  
                    // 当图片高度大于屏幕高度时，将图片等比例压缩，使它可以完全显示出来  
                    float ratio = height / (bitmapHeight * 1.0f);  
                    matrix.postScale(ratio, ratio);  
                    float translateX = (width - (bitmapWidth * ratio)) / 2f;  
                    // 在横坐标方向上进行偏移，以保证图片居中显示  
                    matrix.postTranslate(translateX, 0);  
                    totalTranslateX = translateX;  
                    totalRatio = initRatio = ratio;  
                }  
                currentBitmapWidth = bitmapWidth * initRatio;  
                currentBitmapHeight = bitmapHeight * initRatio;  
            } else {  
                // 当图片的宽高都小于屏幕宽高时，直接让图片居中显示  
                float translateX = (width - sourceBitmap.getWidth()) / 2f;  
                float translateY = (height - sourceBitmap.getHeight()) / 2f;  
                matrix.postTranslate(translateX, translateY);  
                totalTranslateX = translateX;  
                totalTranslateY = translateY;  
                totalRatio = initRatio = 1f;  
                currentBitmapWidth = bitmapWidth;  
                currentBitmapHeight = bitmapHeight;  
            }  
            canvas.drawBitmap(sourceBitmap, matrix, null);  
        }  
    }  
       
    /** 
     * 计算两个手指之间的距离。 
     *  
     * @param event 
     * @return 两个手指之间的距离 
     */
    private double distanceBetweenFingers(MotionEvent event) {  
        float disX = Math.abs(event.getX(0) - event.getX(1));  
        float disY = Math.abs(event.getY(0) - event.getY(1));  
        return Math.sqrt(disX * disX + disY * disY);  
    }  
       
    /** 
     * 计算两个手指之间中心点的坐标。 
     *  
     * @param event 
     */
    private void centerPointBetweenFingers(MotionEvent event) {  
        float xPoint0 = event.getX(0);  
        float yPoint0 = event.getY(0);  
        float xPoint1 = event.getX(1);  
        float yPoint1 = event.getY(1);  
        centerPointX = (xPoint0 + xPoint1) / 2;  
        centerPointY = (yPoint0 + yPoint1) / 2;  
    }  
       
}